/**
 * 添加宠物页面
 * 功能：新增宠物信息，包含头像上传、基本资料填写、数据校验、保存等
 */

const app = getApp();
const apiService = require('../../../utils/api.js');

Page({
	/**
	 * 页面的初始数据
	 */
	data: {
    // 系统状态栏高度
    statusBarHeight: 0,
    
    // 导航栏滚动状态
    scrollY: 0,
    navbarOpacity: 0,  // 导航栏背景透明度 (0-1)
    navbarTextColor: '#FFFFFF', // 导航栏文字颜色
    
    // 页面模式
    mode: 'add', // 'add' 添加模式, 'edit' 编辑模式
    petId: '', // 编辑时的宠物ID
    pageTitle: '添加宠物', // 页面标题
    fromPage: '', // 来源页面
    
    // 表单数据
    formData: {
      avatar: '', // 头像图片路径
      nickname: '', // 昵称
      category: '', // 类别：cat/dog
      breed: '', // 品种
      gender: '', // 性别：male/female/unknown
      birthDate: '', // 出生日期
      weight: '' // 体重
    },
    
    // 页面状态
    isLoading: false, // 保存中状态
    canSave: false, // 是否可保存
    
    // 选择器相关

    today: '' // 今天日期
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad(options) {
    console.log('添加宠物页面加载', options)
    
    // 记录来源页面
    if (options.from) {
      this.setData({
        fromPage: options.from
      })
    }
    
    // 获取系统信息
    this.getSystemInfo()
    
    // 初始化今天日期
    this.initTodayDate()
    
    // 处理编辑模式
    this.handleEditMode(options)
	},

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow() {
    console.log('添加宠物页面显示')
  },

  /**
   * 获取系统信息
   */
  getSystemInfo() {
    try {
      const systemInfo = wx.getSystemInfoSync()
      const statusBarHeight = systemInfo.statusBarHeight || 44
      
      this.setData({
        statusBarHeight: statusBarHeight
      })
      
      console.log('系统信息获取成功', { statusBarHeight })
    } catch (error) {
      console.error('获取系统信息失败', error)
      // 使用默认值
      this.setData({
        statusBarHeight: 44
      })
    }
  },

  /**
   * 初始化今天日期
   */
  initTodayDate() {
    const today = new Date()
    const year = today.getFullYear()
    const month = String(today.getMonth() + 1).padStart(2, '0')
    const day = String(today.getDate()).padStart(2, '0')
    const todayString = `${year}-${month}-${day}`
    
    this.setData({
      today: todayString
    })
  },

  /**
   * 处理编辑模式
   */
  handleEditMode(options) {
    if (options.data) {
      try {
        // 解码传入的宠物数据
        const petData = JSON.parse(decodeURIComponent(options.data))
        console.log('解析到的宠物数据:', petData)
        
        if (petData.mode === 'edit') {
          // 设置编辑模式
          this.setData({
            mode: 'edit',
            petId: petData.id,
            pageTitle: '编辑宠物',
            formData: {
              avatar: petData.avatar || '',
              nickname: petData.nickname || '',
              category: petData.category || '',
              breed: petData.breed || '',
              gender: petData.gender || '',
              birthDate: petData.birthDate || '',
              weight: petData.weight || ''
            }
          })
          
          // 检查是否可保存
          this.checkCanSave()
          
          console.log('已切换到编辑模式:', this.data.mode, this.data.formData)
        }
      } catch (error) {
        console.error('解析宠物数据失败:', error)
        wx.showToast({
          title: '数据格式错误',
          icon: 'error',
          duration: 2000
        })
      }
    }
  },

  /**
   * 返回上一页
   */
  onBack() {
    wx.navigateBack({
      delta: 1
    })
  },

  /**
   * 选择头像
   */
  onChooseAvatar() {
    const that = this
    
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album', 'camera'],
      maxDuration: 30,
      camera: 'back',
      success(res) {
        console.log('选择图片成功', res)
        
        const tempFilePath = res.tempFiles[0].tempFilePath
        
        // 更新头像
        that.setData({
          'formData.avatar': tempFilePath
        })
        
        // 检查是否可保存
        that.checkCanSave()
        
        wx.showToast({
          title: '头像设置成功',
          icon: 'success',
          duration: 2000
        })
      },
      fail(error) {
        console.error('选择图片失败', error)
        
        if (error.errMsg.includes('cancel')) {
          return // 用户取消，不显示错误
        }
        
        wx.showToast({
          title: '选择图片失败',
          icon: 'error',
          duration: 2000
        })
      }
    })
  },

  /**
   * 昵称输入
   */
  onNicknameInput(e) {
    const value = e.detail.value.trim()
    
    this.setData({
      'formData.nickname': value
    })
    
    // 检查是否可保存
    this.checkCanSave()
  },

  /**
   * 品种输入
   */
  onBreedInput(e) {
    const value = e.detail.value.trim()
    
    this.setData({
      'formData.breed': value
    })
    
    // 检查是否可保存
    this.checkCanSave()
  },

  /**
   * 选择类别
   */
  onCategorySelect(e) {
    const category = e.currentTarget.dataset.category
    console.log('选择类别', category)
    
    this.setData({
      'formData.category': category
    })
    
    // 检查是否可保存
    this.checkCanSave()
  },

  /**
   * 选择性别
   */
  onGenderSelect(e) {
    const gender = e.currentTarget.dataset.gender
    console.log('选择性别', gender)
    
    this.setData({
      'formData.gender': gender
    })
    
    // 检查是否可保存
    this.checkCanSave()
  },



  /**
   * 选择出生日期
   */


  /**
   * 出生日期选择器确认
   */
  onBirthdayConfirm(e) {
    const birthDate = e.detail.value;
    console.log('选择出生日期', birthDate);

    this.setData({
      'formData.birthDate': birthDate,
      showBirthdayPicker: false
    });

    // 检查是否可保存
    this.checkCanSave();
  },

  /**
   * 出生日期选择器取消
   */


  /**
   * 体重输入
   */
  onWeightInput(e) {
    let value = e.detail.value.trim()
    
    // 只允许数字和小数点
    value = value.replace(/[^\d.]/g, '')
    
    // 只允许一个小数点
    const dotIndex = value.indexOf('.')
    if (dotIndex !== -1) {
      value = value.substring(0, dotIndex + 1) + value.substring(dotIndex + 1).replace(/\./g, '')
      
      // 小数点后最多两位
      if (value.length > dotIndex + 3) {
        value = value.substring(0, dotIndex + 3)
      }
    }
    
    // 最大值限制（999.99kg）
    const numValue = parseFloat(value)
    if (numValue > 999.99) {
      value = '999.99'
    }
    
    this.setData({
      'formData.weight': value
    })
    
    // 检查是否可保存
    this.checkCanSave()
  },

  /**
   * 检查是否可保存
   */
  checkCanSave() {
    const { nickname, category, breed, gender, birthDate, weight } = this.data.formData;

    // 必填项：昵称、类别、品种、性别、出生日期、体重
    const canSave = nickname && category && breed && gender && birthDate && weight;

    console.log('检查是否可保存', {
      nickname,
      category,
      breed,
      gender,
      birthDate,
      weight,
      canSave
    });

    this.setData({
      canSave: canSave
    });
  },

  /**
   * 保存宠物信息
   */
  async onSave() {
    if (!this.data.canSave || this.data.isLoading) {
      return
    }
    
    console.log('开始保存宠物信息', this.data.formData)
    
    // 最后校验
    const validationResult = this.validateForm()
    if (!validationResult.valid) {
      wx.showToast({
        title: validationResult.message,
        icon: 'error',
        duration: 2000
      })
      return
    }
    
    // 设置保存中状态
    this.setData({
      isLoading: true
    })
    
    try {
      // 准备保存数据
      const petData = {
        ...this.data.formData,
        createTime: new Date().toISOString(),
        updateTime: new Date().toISOString()
      }
      
      // 如果有头像，先上传头像
      if (petData.avatar && petData.avatar.startsWith('http://tmp/')) {
        petData.avatar = await this.uploadAvatar(petData.avatar)
      }
      
      // 模拟保存到服务器
      console.log('[添加宠物] 开始调用savePetToServer');
      const saveResult = await this.savePetToServer(petData)
      console.log('[添加宠物] savePetToServer返回结果:', saveResult);
      
      // 保存宠物信息成功后，刷新宠物列表缓存
      if (saveResult.success) {
        console.log('[添加宠物] 保存成功，准备刷新缓存');
        if (this.data.mode === 'add') {
          this.setData({
            newPetId: saveResult.petId
          })
          console.log('[添加宠物] 添加宠物成功，新宠物ID:', saveResult.petId);
        } else {
          console.log('[添加宠物] 编辑宠物成功');
        }
        
        // 无论是添加还是编辑，都需要刷新宠物列表缓存
        console.log('[添加宠物] 开始刷新宠物列表缓存');
        const app = getApp();
        const dataManager = app.getDataManager();
        await dataManager.getPetList(true).catch(err => {
          console.warn('[添加宠物] 刷新宠物列表缓存失败:', err);
        });
        console.log('[添加宠物] 宠物列表缓存刷新完成');
      } else {
        console.error('[添加宠物] 保存失败，不刷新缓存');
      }
      
      // 保存成功
      wx.showToast({
        title: this.data.mode === 'edit' ? '更新成功' : '保存成功',
        icon: 'success',
        duration: 2000
      })
      
      // 延迟返回上一页
      setTimeout(() => {
        this.handleSaveSuccessNavigation()
      }, 1500)
      
    } catch (error) {
      console.error('[添加宠物] 保存宠物信息失败', error)
      console.error('[添加宠物] 错误详情:', error.message, error.stack);
      
      wx.showToast({
        title: error.message || '保存失败',
        icon: 'error',
        duration: 2000
      })
    } finally {
      // 重置保存状态
      this.setData({
        isLoading: false
      })
    }
  },

  /**
   * 处理保存成功后的导航
   */
  handleSaveSuccessNavigation() {
    console.log('[添加宠物] 处理保存成功后的导航，来源页面:', this.data.fromPage)
    
    if (this.data.fromPage === 'foster-care-detail') {
      // 如果来源是寄养预约页面，返回并刷新宠物列表
      const pages = getCurrentPages()
      if (pages.length > 1) {
        const prevPage = pages[pages.length - 2]
        if (prevPage && prevPage.route === 'pages/booking/foster-care-detail/index') {
          // 通知上一页刷新宠物列表，并传递新创建的宠物ID
          if (typeof prevPage.refreshPetList === 'function') {
            prevPage.refreshPetList(this.data.newPetId)
          }
          // 如果有新创建的宠物，设置为选中状态
          if (this.data.newPetId && typeof prevPage.selectNewPet === 'function') {
            prevPage.selectNewPet(this.data.newPetId)
          }
        }
      }
    }
    
    // 返回上一页
    console.log('[添加宠物] 准备返回上一页');
    wx.navigateBack({
      delta: 1,
      success: () => {
        console.log('[添加宠物] 返回上一页成功');
      },
      fail: (error) => {
        console.error('[添加宠物] 返回上一页失败:', error);
      }
    })
  },

  /**
   * 表单校验
   */
  validateForm() {
    const { nickname, category, breed, gender, birthDate, weight } = this.data.formData;

    // 昵称校验
    if (!nickname) {
      return { valid: false, message: '请输入宠物昵称' };
    }
    if (nickname.length > 20) {
      return { valid: false, message: '宠物昵称不能超过20个字符' };
    }

    // 类别校验
    if (!category) {
      return { valid: false, message: '请选择宠物类别' };
    }
    if (!['cat', 'dog'].includes(category)) {
      return { valid: false, message: '宠物类别无效' };
    }

    // 品种校验
    if (!breed) {
      return { valid: false, message: '请填写宠物品种' };
    }
    if (breed.length > 30) {
      return { valid: false, message: '宠物品种不能超过30个字符' };
    }

    // 性别校验
    if (!gender) {
      return { valid: false, message: '请选择宠物性别' };
    }
    if (!['male', 'female', 'unknown'].includes(gender)) {
      return { valid: false, message: '宠物性别无效' };
    }

    // 出生日期校验
    if (!birthDate) {
      return { valid: false, message: '请选择出生日期' };
    }
    if (new Date(birthDate) > new Date()) {
      return { valid: false, message: '出生日期不能晚于今天' };
    }

    // 体重校验
    if (!weight) {
      return { valid: false, message: '请填写宠物体重' };
    }
    const weightNum = parseFloat(weight);
    if (isNaN(weightNum) || weightNum <= 0) {
      return { valid: false, message: '请填写有效的体重' };
    }
    if (weightNum > 999.99) {
      return { valid: false, message: '体重不能超过999.99kg' };
    }

    return { valid: true };
  },

  /**
   * 上传头像
   */
  uploadAvatar(tempFilePath) {
    return new Promise((resolve, reject) => {
      // 这里应该调用实际的上传接口
      // 暂时模拟上传成功
      setTimeout(() => {
        const uploadedUrl = this.data.formData.category === 'dog' ? '/assets/common/img_dog_avatar_default.png' : '/assets/common/img_cat_avatar_default.png'
        resolve(uploadedUrl)
      }, 1000)
    })
  },

  /**
   * 保存宠物信息到服务器
   */
  async savePetToServer(petData) {
    try {
      console.log('[添加宠物] savePetToServer开始执行，模式:', this.data.mode);
      // 转换数据格式以适配API
      const apiData = {
        name: petData.nickname,
        gender: this.convertGender(petData.gender),
        category: this.convertCategory(petData.category),
        weight: parseFloat(petData.weight) || 0,
        isSterilized: false, // 暂时设为false，后续可以添加UI选择
        species: petData.breed,
        avatar: petData.avatar,
        birthday: petData.birthDate ? Math.floor(new Date(petData.birthDate).getTime() / 1000) : 0
      };

      console.log('[添加宠物] 准备发送的API数据:', apiData);
      
      let result;
      if (this.data.mode === 'edit') {
        // 编辑模式：更新现有宠物
        console.log('[添加宠物] 调用updatePet API，宠物ID:', this.data.petId);
        result = await apiService.updatePet(this.data.petId, apiData);
        console.log('[添加宠物] updatePet API返回结果:', result);
      } else {
        // 添加模式：创建新宠物
        console.log('[添加宠物] 调用addPet API');
        result = await apiService.addPet(apiData);
        console.log('[添加宠物] addPet API返回结果:', result);
      }
      
      if (result.success) {
        console.log('[添加宠物] API调用成功，返回数据:', result.data);
        return { success: true, petId: result.data._id };
      } else {
        console.error('[添加宠物] API调用失败:', result.message);
        throw new Error(result.message);
      }
    } catch (error) {
      console.error('[添加宠物] savePetToServer异常:', error);
      console.error('[添加宠物] 异常详情:', error.message, error.stack);
      throw error;
    }
  },

  /**
   * 转换性别格式
   */
  convertGender(gender) {
    const genderMap = {
      'male': '公',
      'female': '母',
      'unknown': '公' // 不确定时默认设为公
    };
    return genderMap[gender] || '公';
  },

  /**
   * 转换类别格式
   */
  convertCategory(category) {
    const categoryMap = {
      'dog': '狗狗',
      'cat': '猫猫'
    };
    return categoryMap[category] || '狗狗';
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
    console.log('添加宠物页面渲染完成')
	},

	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide() {
    console.log('添加宠物页面隐藏')
	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload() {
    console.log('添加宠物页面卸载')
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {
    console.log('添加宠物页面下拉刷新')
    wx.stopPullDownRefresh()
	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {
    console.log('添加宠物页面上拉触底')
	},

	/**
	 * 页面滚动监听
	 */
	onPageScroll(e) {
		const scrollY = e.scrollTop;
		
		// 计算导航栏背景透明度，滚动距离0-100px内从透明变为不透明
		const maxScrollDistance = 100; // 滚动距离阈值（像素）
		const opacity = Math.min(scrollY / maxScrollDistance, 1);
		
		// 计算文字颜色，透明度达到0.5时开始变黑
		const textColor = opacity >= 0.5 ? '#120E0C' : '#FFFFFF';
		
		// 只有在透明度或文字颜色发生变化时才更新
		if (this.data.navbarOpacity !== opacity || this.data.navbarTextColor !== textColor) {
			this.setData({
				scrollY: scrollY,
				navbarOpacity: opacity,
				navbarTextColor: textColor
			});
		}
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {
    return {
      title: '我在添加新的宠物信息',
      path: '/pages/pet/add-pet/index'
    }
	}
})
